package empresa;

import empresa.Sistema.Retorno;
//Nodo del arbol
//Clase no accesible fuera del package
public class Empresa {
	Nodo raiz;
	public Empresa( ) {
        raiz = null;
     }
	public boolean esArbolVacio() {
		return (raiz == null) ;
	}
	public void crearOrg(String cargo ) {
		 raiz = crearOrg( cargo, raiz );
	}
	//Crea el organigrama
    private Nodo crearOrg(String cargo,Nodo a ) {
        if( raiz == null )
             //a = new Nodo( "1",cargo );
        	a = new Nodo(cargo);
        return a;
    }
	
    public Empresa vaciarEmpresa(Empresa e){
    	e.raiz=null;
		return e;
	}
    
    
    
  
    public Retorno NuevoCargo(Empresa e, String cargoPadre, String nuevoCargo){
		Nodo nuevo = null;
		nuevo = buscarCargo(cargoPadre, raiz);
		if (nuevo==null){
			System.out.print("Error no existe Cargo Padre  "); 
			return Retorno.ERROR;
		}else{
			if ( buscarCargo(nuevoCargo, raiz )!= null) {
				System.out.print("Error  existe Cargo   "); 
				return Retorno.ERROR;
			}
			if (nuevo.getHijo()== null){
				nuevo.setHijo(new Nodo( nuevoCargo, nuevo,  nuevo));
				return Retorno.OK;
			}else {
				insertarCar(nuevo.getHijo(), 1, nuevoCargo);
				return Retorno.OK;
			}
		}
	}

    public void insertarCar(Nodo n, int niveles, String descCap){
	if (n!=null){
            if(n.getHno() == null){
                niveles+=1;
		n.setHno(new Nodo( descCap, n.padre, n));
            }else{
		insertarCar(n.getHno(), niveles + 1, descCap);
            }
	}
    }
    //Pre: No se puede eliminar el primer cargo de la empresa
    public Retorno eliminarCargo(String cargo, Nodo n ){
    	Nodo unCargo=buscarCargo(cargo,n);
    	if (unCargo != null){
    		if (unCargo.hijo == null){
    				if (unCargo.padre.hijo.cargo.equals(cargo)){
    				    unCargo.padre.hijo=unCargo.hno;
    				}else{	eliminarHno(cargo, unCargo.padre.hijo);	}
    				return Retorno.OK;
    	    }else{ return Retorno.ERROR;      }
    	}else{return Retorno.ERROR;    	}
    }
	private void eliminarHno(String cargo,Nodo h) {
		System.out.println(h.hno.cargo+" = "+cargo);
		if (h.hno!=null){
			if (h.hno.cargo.equals(cargo)){
				System.out.println("SISI");
				h.hno = h.hno.hno; 
			}else{eliminarHno(cargo,h.hno);}
		}	
	}
	private Nodo buscarCargo(String cPadre, Nodo n ){
		if (n== null)
			return null;
		if (n.cargo.equals(cPadre))
			return n;
		Nodo retorno;
		retorno = buscarCargo(cPadre, n.hno);
		if (retorno == null)
			return buscarCargo(cPadre, n.hijo);
		else
			return retorno;
	}
    
	

    public Retorno listarJerarquia(Empresa e) {
        if(e==null){
            return Retorno.ERROR;
        }else{
             listarJerarquia(e.raiz,"",1);
        }
        return Retorno.OK;
    }

    private void listarJerarquia(Nodo n,String tab,int nro){
         if(n!=null){
            System.out.println(tab + nro + " " +  n.cargo);
            listarJerarquia(n.getHijo(),"   "+tab + nro+".",1);
            listarJerarquia(n.getHno(),tab,nro+1);
        }
    }
    
    
    public Retorno AsignarPersona( String cargo, int ci, String nombre, Nodo n){
    	Nodo unCargo=buscarCargo(cargo,n);
    	String retorno;
    	if (unCargo != null){
    		unCargo.persona.asignarPersona(ci,nombre);
    		return Retorno.OK;
    	}else{
    		return Retorno.ERROR;
    	}
    }
	public Retorno ListarPersonas(Nodo n, String cargo) {
		Nodo unCargo=buscarCargo(cargo,n);
    	if (unCargo != null){
    		unCargo.persona.ListarPersonas();
    		return Retorno.OK;
    	}else{
    		return Retorno.ERROR;
    	}
	}
	public Retorno ListarSuperCargos(Nodo n, String cargo) {
		Nodo unCargo=buscarCargo(cargo,n);
		if (unCargo.padre==null){
			System.out.println(unCargo.cargo);
			return Retorno.OK;
		}			
			ListarSuperCargos(n,unCargo.padre.cargo);
			System.out.println(unCargo.cargo);
			return Retorno.OK;
	} 
	public Retorno EliminarPersona(Empresa e, int ci){
		 if(e==null){
	            return Retorno.ERROR;
	        }else{
	        	return EliminarPersona(e.raiz,ci);
	        }
	       
		
	}

	private Retorno EliminarPersona(Nodo n, int ci){
		if(n!=null){
                    if (n.persona.buscarCi(ci)){
                        Nodo nodoPadre=n.getPadreDePersona(n.persona.devolverPersona(ci));
                        if(nodoPadre!=null){
                            if(nodoPadre.getHno()!=null){
                                 n.persona.eliminarPersonas(ci);
                                   EliminarPersona(n.getHijo(),ci);
                                   EliminarPersona(n.getHno(),ci);
                                   return Retorno.OK;
                            }
                          if(nodoPadre.getHijo()!=null){
                             if(nodoPadre.getHijo().getPersona().getNodoPersona()!=null){
                                       return Retorno.ERROR;
                              }else{
                                   n.persona.eliminarPersonas(ci);
                                   EliminarPersona(n.getHijo(),ci);
                                   EliminarPersona(n.getHno(),ci);
                              }
                           }else{
                                  n.persona.eliminarPersonas(ci);
                                  EliminarPersona(n.getHijo(),ci);
                                  EliminarPersona(n.getHno(),ci);
                           }

                            }else{
                                   n.persona.eliminarPersonas(ci);
                                   EliminarPersona(n.getHijo(),ci);
                                   EliminarPersona(n.getHno(),ci);
                            }
				return Retorno.OK;
			}else{
				EliminarPersona(n.getHijo(),ci);
			}
		}
		return Retorno.ERROR;
	}
	
}
class Nodo {
	 String nro;
	 String cargo;
	 Nodo hijo = null;
	 Nodo hno = null;
	 Nodo padre = null;
	 Nodo anterior = null;
	 Persona persona; 
 // Constructor
 Nodo( String c ) {

	 cargo = c;
     hijo=hno=padre=anterior= null;
     persona = new Persona();
 }
 Nodo( String unCargo,Nodo padre, Nodo anterior ) {

	 cargo = unCargo;
	 this.padre = padre;
	 this.anterior = anterior;
	 hijo = hno  = null;
	 persona = new Persona();
	
 }
	Nodo getHno(){
		return hno;
	}
	void setHno(Nodo hn){
		hno=hn;
	}

	Nodo getHijo(){
		return hijo;
	}
	void setHijo(Nodo h){
		hijo=h;
	}

	Nodo getPadre(){

		return padre;
	}

	void setPadre(Nodo p){
		padre = p;

	}
	public String getCargo() {
		return cargo;
	}


	public void setCargo(String c) {
		cargo = c;
	}
	public String getNro() {
		return nro;
	}
	public void setNro(String n) {
		nro = n;
	}
	
	public Persona getPersona() {
		return persona;
	}
	public void setPersona(Persona p) {
		persona = p;
	}

    public Nodo getPadreDePersona(NodoPersona p) {
        if(p!=null){
            if(this.getPersona().getNodoPersona()==p){
                return this;
            }else{
                if(this.getHijo()!=null){
                    if(this.getHijo().getPadreDePersona(p)!=null){
                        return this.getHijo().getPadreDePersona(p);
                    }else{
                        if(this.getHno()!=null){
                            if(this.getHno().getPadreDePersona(p)!=null){
                                return this.getHno().getPadreDePersona(p);
                            }
                        }
                    }

                }else if(this.getHno()!=null){
                    return this.getHno().getPadreDePersona(p);
                }else{
                    return null;
                }
            }
        }else{
            return null;
        }
        return null;
    }
	
	
}
/********************* fin clase Nodo **********************/